feat: derive execution timing from a summary lifecycle plan - #482

Stacked on #476.

Rebuilt into the linear stack on main. Conflict resolutions are recorded in the messages of: "test: carry a chosen lifecycle through timing to physical compilation".

Why

Agreed layering: the summary maintenance lifecycle layer sits between logical
Post-ASAP and physical compilation, and a chosen lifecycle assignment is what
decides each node's execution timing (precompute vs query time). Today timing is
hard-coded by logical strategies when they build candidates, and a lifecycle
choice (e.g. Ephemeral vs ContinuouslyMaintained) never reaches the DAG, so
it cannot change what runs in precompute.

What

• SummaryMaintenanceLifecyclePlan::execution_timed_dag() -> Result<PostAsapDag, SummaryMaintenanceTimingError>
  applies the plan's lifecycle choices to every node via with_execution_phases:
  • a retained state (ContinuouslyMaintained, Shared, Prepared) and every
    node feeding it run at ingestion time;
  • readouts, other consumers and Ephemeral states run at query time; the
    deployment supplies their raw data as a query-time source;
  • an Ephemeral state feeding a retained state runs at ingestion time (query
    time may not feed ingestion time);
  • a state without a selected lifecycle, or a maintained population the plan
    does not list, is refused.
• Design doc: the "placement ownership is an open question" paragraph is replaced
  by the four-layer contract (logical → lifecycle → physical → deployment).

Hard-coded timing in logical strategies is left in place for a follow-up; with
Planner's default selection the timed DAG equals today's for the PromQL fixtures.

Before this PR

ContinuouslyMaintained or Ephemeral  →  same DAG, same precompute contents

After this PR

let plan = candidates.select(&[(state, SummaryMaintenanceLifecycle::Ephemeral)])?;
let timed = plan.execution_timed_dag()?;   // Ephemeral: everything at query time
// physical compilation: precompute empty, raw source read at query time

Validation

Unit tests for every lifecycle kind, a shared state with two readouts, an
Ephemeral state feeding a retained state, unselected and unplanned states.
End to end (summary_maintenance_lifecycle_e2e): Planner's selection reproduces
today's timing for quantile_over_time, quantile and sum by(job)(rate); a
Continuous choice puts exactly the state in precompute while Ephemeral leaves
precompute empty, and both return the same p99. cargo fmt --check and
cargo clippy --workspace --all-targets -- -D warnings pass; asap-aware-mapping
478 passed; workspace passes except the pre-existing
devtools dag_export::workload_node_ids_make_smaller_topk_reuse_explicit.

Follow-ups

• Remove hard-coded timing in replacement.rs, exact_composition.rs,
  maintained_population.rs, and move feat: expose physical-ready logical candidates in Planner selection #472's grouped Rate→Sum placement pair to
  the lifecycle layer.
• Derive the precompute frontier from timing inside the physical planner (the e2e
  test derives it today).

🤖 Generated with Claude Code